{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Entropies & Dimensions\n",
    "\n",
    "\n",
    "Topics:\n",
    "* Entropies from **DynamicalSystems.jl**\n",
    "* Generalized Dimension\n",
    "* Automated dimension estimation!\n",
    "* Other related concepts\n",
    "* Docstrings\n",
    "\n",
    "---\n",
    "\n",
    "# Generalized Entropy\n",
    "\n",
    "* In the study of dynamical systems there are many quantities that identify as \"entropy\".\n",
    "* These quantities are not the more commonly known [thermodynamic ones](https://en.wikipedia.org/wiki/Entropy), used in Statistical Physics. \n",
    "* Rather, they are more like the entropies of [information theory](https://en.wikipedia.org/wiki/Entropy_(information_theory), which represent information contained within a dataset. \n",
    "* In general, the more \"uncertain\" or \"random\" the dataset is, the larger its entropy will be. On the other hand, the lower the entropy, the more \"predictable\" the dataset becomes.\n",
    "\n",
    "\n",
    "Let $p$ be an array of probabilities (such that it sums to 1). Then the generalized entropy is defined as \n",
    "\n",
    "$$\n",
    "R_\\alpha(p) = \\frac{1}{1-\\alpha}\\log\\left(\\sum_i p[i]^\\alpha\\right)\n",
    "$$\n",
    "\n",
    "and is also called [Rényi entropy](https://en.wikipedia.org/wiki/R%C3%A9nyi_entropy). Other entropies, like e.g. the [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory) are generalized by it, since for $\\alpha = 1$, the Rényi entropy becomes the Shannon entropy,\n",
    "\n",
    "$$\n",
    "R_1(p) = -\\left(\\sum_i p[i] \\log (p[i]) \\right)\n",
    "$$\n",
    "\n",
    "The Rényi entropy can be computed for a specific dataset, given $p$. But how does one get $p$?\n",
    "1. $p$ represents the probability that a point of a dataset falls into a specific \"bin\". \n",
    "2. It is nothing more than the (normalized) histogram of the dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DynamicalSystems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's generate a dataset so that we can practice calculating entropies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-dimensional Dataset{Float64} with 100000 points\n",
       " 0.748244   0.22896    0.911994\n",
       " 0.938412   0.461608   0.92072 \n",
       " 0.543664   0.637526   0.449897\n",
       " 0.437051   0.410596   0.615079\n",
       " 0.291084   0.944725   0.781869\n",
       " 0.339147   0.759416   0.973281\n",
       " 0.865328   0.838523   0.150525\n",
       " 0.919007   0.451689   0.513249\n",
       " 0.292374   0.024548   0.868366\n",
       " 0.244673   0.373569   0.101827\n",
       " 0.0375189  0.646712   0.622049\n",
       " 0.849457   0.867411   0.850035\n",
       " 0.419948   0.578105   0.860869\n",
       " ⋮                             \n",
       " 0.464328   0.293143   0.430965\n",
       " 0.18367    0.379628   0.861446\n",
       " 0.483306   0.0830311  0.262124\n",
       " 0.863597   0.592292   0.76599 \n",
       " 0.508551   0.139351   0.238507\n",
       " 0.796334   0.704294   0.861017\n",
       " 0.0262872  0.488212   0.991447\n",
       " 0.264067   0.785628   0.800286\n",
       " 0.497464   0.82473    0.487972\n",
       " 0.906668   0.709457   0.297275\n",
       " 0.0686283  0.804324   0.261919\n",
       " 0.257962   0.811167   0.142184\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 100000\n",
    "randomdata = Dataset(rand(N,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "```julia\n",
    "genentropy(α, ε, dataset::AbstractDataset; base = e)\n",
    "```\n",
    "* This function calculates the generalized entropy of order `α`.\n",
    "* It first calculates the probability array $p$.\n",
    "* The \"histogram\" is created by partitioning the `dataset` into boxes of size `ε`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "6.897719407233242"
      ],
      "text/plain": [
       "6.897719407233242"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(2, 0.1, randomdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "11.416343367123178"
      ],
      "text/plain": [
       "11.416343367123178"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(2, 0.01, randomdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "11.512885465769227"
      ],
      "text/plain": [
       "11.512885465769227"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(2, 0.001, randomdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "11.512925464969248"
      ],
      "text/plain": [
       "11.512925464969248"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(2, 0.0001, randomdata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the output of `genentropy` changed with changing $\\varepsilon$ until we hit $\\varepsilon = 0.001$. \n",
    "\n",
    "At this point the value for the entropy has already saturated. There's no use in partitioning the dataset in smaller boxes.\n",
    "\n",
    "---\n",
    "\n",
    "Now let's calculate the entropy of a coin toss!\n",
    "\n",
    "First, let's create an array, `y`, that stores the results of coin tosses as `0`s or `1`s for `1000000` tosses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.0\n",
       " 1.0\n",
       " 0.0\n",
       " 1.0\n",
       " 0.0\n",
       " 1.0\n",
       " 0.0\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0\n",
       " 0.0\n",
       " 0.0\n",
       " ⋮  \n",
       " 0.0\n",
       " 1.0\n",
       " 1.0\n",
       " 0.0\n",
       " 1.0\n",
       " 0.0\n",
       " 0.0\n",
       " 0.0\n",
       " 0.0\n",
       " 1.0\n",
       " 1.0\n",
       " 0.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = Float64.(rand(Bool, 1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.693146934157925"
      ],
      "text/plain": [
       "0.693146934157925"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sh = genentropy(1, 0.1, y) # Renyi entropy with α = 1 is the Shannon entropy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above number should be log(2) [by definition](https://en.wikipedia.org/wiki/Shannon_(unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isapprox(sh, log(2), rtol = 1e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`genentropy` is conveniently used with `trajectory` outputs.\n",
    "\n",
    "Here we create a trajectory for a towel map,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3-dimensional Dataset{Float64} with 100000 points\""
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "towel = Systems.towel()\n",
    "tr = trajectory(towel, N-1);\n",
    "summary(tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and calculate its entropy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "9.47195269047054"
      ],
      "text/plain": [
       "9.47195269047054"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(1, 0.01, tr) # The result is with log base-e !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also compare the entropy of the above dataset (a trajectory of the towel map) with that of a random dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "11.444156175223966"
      ],
      "text/plain": [
       "11.444156175223966"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "genentropy(1, 0.01, randomdata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* As expected, the entropy of the random dataset is higher.\n",
    "\n",
    "---\n",
    "\n",
    "How much time does the computation take?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  15.797 ms (42 allocations: 3.05 MiB)\n"
     ]
    }
   ],
   "source": [
    "using BenchmarkTools\n",
    "@btime genentropy(1, 0.01, $tr);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specialized histogram\n",
    "* Partitioning the dataset (i.e. generating a \"histogram\") is in general a costly operation that depends exponentially on the number of dimensions.\n",
    "* In this specific application however, we can tremendously reduce the memory allocation and time spent!\n",
    "\n",
    "Let's get the array of probabilities $p$ for size ε where `tr` is the trajectory of the towel map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19407-element Array{Float64,1}:\n",
       " 1.0e-5 \n",
       " 4.0e-5 \n",
       " 2.0e-5 \n",
       " 5.0e-5 \n",
       " 1.0e-5 \n",
       " 1.0e-5 \n",
       " 7.0e-5 \n",
       " 0.00015\n",
       " 4.0e-5 \n",
       " 5.0e-5 \n",
       " 1.0e-5 \n",
       " 7.0e-5 \n",
       " 5.0e-5 \n",
       " ⋮      \n",
       " 3.0e-5 \n",
       " 5.0e-5 \n",
       " 8.0e-5 \n",
       " 1.0e-5 \n",
       " 0.00013\n",
       " 2.0e-5 \n",
       " 2.0e-5 \n",
       " 2.0e-5 \n",
       " 0.00011\n",
       " 1.0e-5 \n",
       " 4.0e-5 \n",
       " 2.0e-5 "
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ε = 0.01\n",
    "p = non0hist(ε, tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a sanity check, showing our probabilities should sum to roughly `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.9999999999999992"
      ],
      "text/plain": [
       "0.9999999999999992"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How long does generating the histogram take?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  15.580 ms (37 allocations: 3.05 MiB)\n"
     ]
    }
   ],
   "source": [
    "@btime non0hist($ε, $tr);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How long does this take if we create 9-dimensional data and compare again?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  48.882 ms (44 allocations: 28.53 MiB)\n"
     ]
    }
   ],
   "source": [
    "nine = Dataset(rand(N, 9))\n",
    "@btime non0hist($ε, $nine);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We went from dimension 3 to dimension 9 but the time roughly only tripled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Attractor Dimension\n",
    "1. There are numerous methods that one can use to calculate a so-called \"dimension\" of a\n",
    "dataset, like for example the [Fractal dimension](https://en.wikipedia.org/wiki/Fractal_dimension).\n",
    "\n",
    "2. Most of the time these dimensions indicate some kind of scaling behavior. \n",
    "\n",
    "3. For example, the scaling of `genentropy` with decreasing `ε` gives the so-called \"generalized dimension\".\n",
    "\n",
    "\n",
    "$ E \\approx -D\\log(\\varepsilon)$ with $E$ the entropy and $D$ the \"dimension\".\n",
    "\n",
    "---\n",
    "I want to know dimension of attractor of the Towel Map!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"3-dimensional Dataset{Float64} with 1000001 points\""
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "towel = Systems.towel()\n",
    "towel_tr = trajectory(towel, 1000000);\n",
    "summary(towel_tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that more points = more precision = more computations = more time!\n",
    "\n",
    "Now I want to compute `genentropy` for different ε.\n",
    "\n",
    "Which ε should we use...?\n",
    "\n",
    "Let's do a \"random\" logspace based guess..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12-element Array{Float64,1}:\n",
       "  0.0001     \n",
       "  0.000284804\n",
       "  0.000811131\n",
       "  0.00231013 \n",
       "  0.00657933 \n",
       "  0.0187382  \n",
       "  0.053367   \n",
       "  0.151991   \n",
       "  0.432876   \n",
       "  1.23285    \n",
       "  3.51119    \n",
       " 10.0        "
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ες = logspace(-4, 1, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12-element Array{Float64,1}:\n",
       " 13.8116 \n",
       " 13.781  \n",
       " 13.5601 \n",
       " 12.5477 \n",
       " 10.4825 \n",
       "  8.23824\n",
       "  6.05165\n",
       "  3.7852 \n",
       "  1.6531 \n",
       " -0.0    \n",
       " -0.0    \n",
       " -0.0    "
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Es = zeros(ες)\n",
    "for (i, ε) ∈ enumerate(ες)\n",
    "    Es[i] = genentropy(1, ε, towel_tr)\n",
    "end\n",
    "Es"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Shorter version:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12-element Array{Float64,1}:\n",
       " 13.8116 \n",
       " 13.781  \n",
       " 13.5601 \n",
       " 12.5477 \n",
       " 10.4825 \n",
       "  8.23824\n",
       "  6.05165\n",
       "  3.7852 \n",
       "  1.6531 \n",
       " -0.0    \n",
       " -0.0    \n",
       " -0.0    "
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Es = genentropy.(1, ες, towel_tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright. Remember that it should be that $E \\approx -D\\log(\\varepsilon)$\n",
    " with $E$ the entropy and $D$ the \"dimension\". \n",
    "\n",
    "Let's plot and see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <Figure size 600x400 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using PyPlot; figure(figsize = (6,4))\n",
    "x = -log.(ες)\n",
    "plot(x, Es); xlabel(\"-log(ε)\"); ylabel(\"Entropy\");\n",
    "plot([x[4], x[4]], [0, 15], color = \"C1\", alpha = 0.5)\n",
    "plot([x[end-3], x[end-3]], [0, 15], color = \"C1\", alpha = 0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What typically happens is that there is some region where this scaling behavior holds, but then it stops holding due to the finite amount of data points.\n",
    "\n",
    "Above, the expected scaling behavior holds between the orange vertical lines.\n",
    "\n",
    "Let's choose the curve points that do fall in the linear regime of the above plot,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([6.07045, 5.02382, 3.97719, 2.93056, 1.88393, 0.837304, -0.209326], [12.5477, 10.4825, 8.23824, 6.05165, 3.7852, 1.6531, -0.0])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = -log.(ες)[4:end-2], Es[4:end-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and find the slope of the curve there, to calculate the dimension, D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.03902652552714"
      ],
      "text/plain": [
       "2.03902652552714"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "offset, slope = linreg(x, y)\n",
    "D = slope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is actually a correct result, the information dimension of the attractor of the towel map is around 2.\n",
    "\n",
    "---\n",
    "\n",
    "* Are the values of `ες` we used good? \n",
    "* For a general dataset, how can we determine them?\n",
    "\n",
    "the function `estimate_boxsizes(dataset; kwargs...)` can help with that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12-element Array{Float64,1}:\n",
       " 0.0001     \n",
       " 0.000187382\n",
       " 0.000351119\n",
       " 0.000657933\n",
       " 0.00123285 \n",
       " 0.00231013 \n",
       " 0.00432876 \n",
       " 0.00811131 \n",
       " 0.0151991  \n",
       " 0.0284804  \n",
       " 0.053367   \n",
       " 0.1        "
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ες = estimate_boxsizes(towel_tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot $E$ vs. $-\\log \\epsilon$ again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <Figure size 600x400 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Es = genentropy.(1, ες, towel_tr)\n",
    "figure(figsize = (6,4))\n",
    "plot(-log.(ες), Es); xlabel(\"-log(ε)\"); ylabel(\"E\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Automated Dimension Estimation\n",
    "\n",
    "Given some arbitrary plot like the one above, is there any algorithm to deduce a scaling region???\n",
    "\n",
    "The function `linear_regions(x, y; kwargs...)` decomposes the function `y(x)` into regions where  the function is linear.\n",
    "\n",
    "It returns the indices of `x` that correspond to linear regions and the approximated tangents at each region!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, 5, 6, 12], [0.0169754, 0.059061, 0.195576, 0.549296, 1.19167, 1.87214])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = -log.(ες)\n",
    "lrs, slopes = linear_regions(x, Es)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linear region 1 starts from index 1 and ends at index 2\n",
      "with corresponding slope 0.01697540475919078\n",
      "\n",
      "linear region 2 starts from index 2 and ends at index 3\n",
      "with corresponding slope 0.059060992416266674\n",
      "\n",
      "linear region 3 starts from index 3 and ends at index 4\n",
      "with corresponding slope 0.19557558745055342\n",
      "\n",
      "linear region 4 starts from index 4 and ends at index 5\n",
      "with corresponding slope 0.5492959963318305\n",
      "\n",
      "linear region 5 starts from index 5 and ends at index 6\n",
      "with corresponding slope 1.1916713297590442\n",
      "\n",
      "linear region 6 starts from index 6 and ends at index 12\n",
      "with corresponding slope 1.8721371361939052\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in 1:length(slopes)\n",
    "    println(\"linear region $(i) starts from index $(lrs[i]) and ends at index $(lrs[i+1])\")\n",
    "    println(\"with corresponding slope $(slopes[i])\")\n",
    "    println()\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The linear region which is biggest is \"probably correct one\".\n",
    "Here the last linear region is the largest; thus the slope is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.8721371361939052"
      ],
      "text/plain": [
       "1.8721371361939052"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slopes[end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This `linear_regions` function seems very shady... Is there any \"easy\" way to visualize what it does? *Say no more!*\n",
    "\n",
    "In this next example, we'll use `ChaosTools`, which belows to `DynamicalSystems`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot, ChaosTools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ChaosTools` provides a function, `plot_linear_regions` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <Figure size 600x400 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(6,4))\n",
    "plot_linear_regions(x, Es)\n",
    "xlabel(\"-log(ε)\"); ylabel(\"E\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adjust the tolerance of `linear_regions` using keyword argument `tol`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHACAYAAABZFZeHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd4VGXC/vHvmZk00oAAEiAQMDRBFgtWIEBQUFfe9ee7YhdMLDQFG3ZA2ZWqdARNAMuuuvrq6q6FIkUEsQAqqDGUgQChBUghdTLn90dwlBBKQjJnJnN/rmsuc848c7hlYObmOc0wTdNERERERDxsVgcQERER8TUqSCIiIiIVqCCJiIiIVKCCJCIiIlKBCpKIiIhIBSpIIiIiIhWoIImIiIhUoIIkIiIiUoEKkoiIiEgFKkgiIiIiFaggiYiIiFTgsDpAoHC73ezZs4fIyEgMw7A6joiISEAwTZO8vDyaNWuGzVaFeSEzgJSWlpoLFy4027dvby5fvrzKr//73/9uAuaCBQuq/NrMzEwT0EMPPfTQQw89LHhkZmZW6Xs7IGaQiouLSUtLY+LEiezYsaNa29i4cSNjx46tdobIyEgAMjMziYqKqvZ2RERE5Mzl5uYSFxfn+R4+UwFRkJYvX07nzp254447GD9+fJVfX1RUxO23305paWm1M/y2Wy0qKkoFSURExMuqenhLQByk3b9/f3r06MHIkSOr9fonnniCtm3b0rJlyxpOJiIiIr4oIGaQfhMdHV3l13z++ee8/fbb/PDDD1x88cW1kEpERER8TUDMIP3G4ahaHzxy5AiDBw/m1VdfpVGjRrWUSkRERHxNQBWkqho2bBh//vOfufbaa62OIiIiIl4UULvYquJf//oX3333HevXr7c6ioiIiHiZClIl9uzZw4gRI/jPf/5DvXr1qrWNrKwssrKyPMv5+flA+eUCIiIiPOtjY2OJjY09u8AiIiJSo1SQKnH33XczfPjwszooe968eYwbN+6E9YmJicctjxkz5qyuryQiIiI1TwWpglmzZpGXl8cTTzxxVtu57777GDBggGc5Pz+fxMREVq5cecIMkoiIiPgWFaQ/SE9P5/nnn2ft2rXY7faz2lbFXWe5ubkAdO3aVReKFBER8XEqSH8wZcoUsrOz6dKlS6XPFxQUAHD//fczfPhwWrVqxebNm70ZUUREpMoyMjJIS0vD6XQSHx/P3XffTdu2ba2O5eGL+VSQ/qC0tJSysjKOHj16ynHFxcUUFxefdpyIiAQOX/ySB1iwYAEpKSkYhoFpmhiGwaRJk0hNTWXQoEFWx/PZfIZpmqZlv7oFfrsXy/Lly+nVq1eVXhsfH8+OHTtYsGBBld+03NxcoqOjycnJ0S42EZE6prIvedM0LfmSd7tNSsrcFJWW8fOvW0nskwT2IAx7EIYjCAw7GAY2m50FixYRG9uMMtPENE3cbn7/2YQyt4nbPPZw8/vPx56rOM40y19fPr78uT/+/Ntz5rHXHDp8mNdeex0MAwwbGDbyf1xKyZ5fsNlspKenk5CQcFa/H9X9/tUMkoiIyFnIyMggJSUFt9sNQLAdSsoAu4OUoQ9w3oWXEduiJcWuMopK3RS73BSXlpX/17OufLmotIziY2OKTjXG5aa41E2R6/fxxcd+LilzH5ev2b2vnDT76E92Abtq8Xfn9CIvuv645eLdP1Oy5xcMwyA1NZUXXnjBklwBVZCKioo8PxcXF1uYRERE/I5pQtERyN0DuVmQuxty93D483/z31tCadn8HJqFFGIzTLoUp3pedtM/tgJbrcvtb4zym3yYponT6bQsRsAUJNM0eeuttzzLH330Eb169SIkJMTCVCIi4hPcZXD0wLHSk3WsBO2GvN9+PvZwFZ7w0kvsQIIDyPasC6eQo4TVauRgu42QIBshDjshDhuhv/0cZCP02H+3pP/Mrz9txu0qxnSVYJa5MN1lYJoYmFx+2aUkJSVhM8BmGNhtBoYBdsPAZhz72Vb+s80A27Gf7ceeO+41fxx37PW/PVfZzzYDXp47lzfeeB23y4VpusE0Kcs7CJQfEhMfH1+rv4enEhDHIL3zzjvcfvvtlJaWHrfeZrMxatQopkyZckbb0TFIIiLWqfZB0K7iE4tO7h7I2/P7bFBeFphlZ5Wv2G1jr7s+Wa4o7t/3/9hbHAJlpZzbuhUXdOlMaFB5kQlx2CuUGRshQb+VnJONsR8rQ+Vjgu02bDbjjH7POnTo4Nn990c1dYzP2fBGvup+/wZEQfIFKkgiItV3soOgX3tlNrdd3/skMz/H1hUcPPsAwZEQ1ez4R2QsRDVn55FSuvX9C/vzfbOELFy4kOTkZJ84gNyKfCpIPk4FSUSkejIyMujSqQOJLQ2ubeugYyM7LaIMmkfZiAo5/SzKadVrVEn5qVCEQk/9ue3rJWTLli2kpqZ6Zt+Sk5MtLW0V1WY+FSQfp4IkIlJFRw9CxmI2vTeZVq6tRFa1DBn2Y7M8zSCqfLbnjzM/RMWW/+yomWNRfb2EBCoVJB+ngiQichqmCQfS4ddPIP0TyPwaqPwrqqDUZFeum125JkENW9LjuoHHz/pENYPwxmA7u9tGif/TdZBERMT/lJXCjjXw66eQ/jEcdlY67MBRk/9mlPJhuouVO8o4VFhenOx2O48++hd69B3rtcgSGFSQRETEuwoPQ8bS8pmijKVQnFP5uMYdoF1/MsPPp03PgbjKTjwI2jRNkpOTazmwBCIVJBERqX3ZW8t3m/36afmMUWWn1Nsc0OoKaHcNtO8PDdsAEAe88mrqSQ+C1nE+Uht0DJKX6BgkEQko7rLyY4jSPy4vRQd/rXxcaDS0vRra9YeEvhBW/6Sb1EHQUh06SNvHqSCJSJ1XlAtbPy+fKcpYDIWHKh/XsM2xWaJroOVlYA/ybk4JKDpIW0REvO/ITkj/tPx4ou1fgLv0xDGGDeIuLZ8lan8tNGpbfvd2ER+mgiQiImfO7YY9638/nmjfpsrHBUdAQlL5TFHbqyE8xrs5Rc6SCpKIiACnuNdZSQFsW3HseKLP4Oj+yjcQHXdslugaiO9eYxdgFLGCCpKIiBx3rzOCITbY4PCSF3nqrxcSV7oNXEWVv7D5Rb8fT3ROJ+06kzpDBUlEJMBlZGSQkpJCs0iTxJtjyOjWiIX79tOxpBQKfzp+sCMMzu1dPlPUrh9ENrUmtEgtU0ESEQlwaWlpBJ8TTMN7Y/m+dTgAzzSK4Z979hIE5Jr1iLr4pvKZojaJEBRmbWARL1BBEhEJYGXuMr7lW9qMa4M72OZZ3+xwEc99WcJnP7tI6HEN/xg33cKUIt6ngiQiEqC2HN7CmDVj2NthLzbKy5HtcAm5b+xh5nf5QPm9zpLiW1sZU8QSKkgiIgGm1F3Kgk0LePn7lyk9dt0i022SvTSbfe/uwyz5/frButeZBCrb6YeIiEhd8XP2z9z631uZuWGmpxzFR8Vzi3EL+9/aj63Mhs1mw263Y7PZdK8zCViaQRIRCQAlZSW8/P3LpG1Ko+zYjWJtho1BnQYx5E9DCHWEMrD7QN3rTOQY3YvNS3QvNhGxyg8HfuDZL59la85Wz7q2Ddry/BXP06lRJwuTidQ+3YtNRESOU+gqZPaG2bz+8+u4TTcADsPBPV3u4Z7z7yFIN4kVOSkVJBGROujbvd8yZs0Ydubt9Kw7L+Y8nrviOdo3bG9hMhH/oIIkIlKHHC09yrTvpvFW+luedcG2YIZ2Hcpdne7CYdPHvsiZ0N8UEZE6Ys2eNYxbM449R/d41nVt3JVxV46jTXQbC5OJ+B8VJBERP5dbksuUb6bw/pb3PevCHGE8eOGD3Nz+Zuw2u4XpRPyTCpKIiB9bkbmC59c+z/7C/Z51lzS9hLFXjCUuMs7CZCL+TQVJRMQPHS46zISvJ/Dx9o8968KDwnn44oe5se2N2AxdB1jkbKggiYj4EdM0WbxjMX9f93cOFR3yrO/evDtjLh9D0/CmFqYTqTtUkERE/MTBwoOM/2o8y3Yu86yLCo5i9CWjub7N9RiGYWE6kbpFBUlExMeZpslH2z5i4tcTyS3J9axPapnE05c9TaOwRhamE6mbVJBERHzY3qN7Gbd2HKt3r/asaxjakCcufYJ+rfpp1kiklqggiYj4INM0eTfjXaZ+O5WjpUc9669tfS2PX/I4DUIbWJhOpO5TQRIR8TGZeZmMWzOOdXvXedY1DmvMM5c9Q++WvS1MJhI4VJBERHyE23Tzz1/+yfT10yl0FXrW35BwA490e4So4DO/E7mInB0VJBERH7A9Zztj1oxhw/4NnnWx4bGMvXwsVzS/wsJkIoFJBUlExEIut4tFmxcxZ+McStwlnvUD2w9k1EWjCA8KtzCdSOBSQRIR8aKMjAzS0tJwOp00bN+Q3Z13s/XoVs/zLSNbMvaKsXRr2s3ClCKigiQi4iULFiwgJSUFw2EQc20MjeMaYxwtP03fZti4o+MdDLtgGGGOMIuTiogKkoiIF2RkZJCSkkJQ0yDihsQRGhfqea54TzEv9X+J6y64zsKEIvJHupuhiIgXpKWlEdIshNaPt/aUI7PMZP+H+9k+bjur31l9mi2IiDdpBklExAvS96fT8pGWOKLKP3aLMovY9couinYWYbPZcDqd1gYUkeOoIImI1LJdebvIvDyToKAgAAq3F7J98nbcBW4ADMMgPj7ewoQiUpF2sYmI1KKs/CxSFqdQFFQEQOHOQpxTnJ5yBOW3FUlOTrYqoohUQgVJRKSW7C/YT8riFHbn7wagodmQnVN3QhHYbDbsdjs2m43U1FQSEhIsTisif6RdbCIiteBg4UFSFqewM28nAK2iWrGg3wJyuueQmpqK0+kkPj6e5ORklSMRH2SYpmlaHSIQ5ObmEh0dTU5ODlFRup+SSF12uOgwd392N1uObAGgeURzFvZfSNPwphYnEwk81f3+1S42EZEalFOcw31L7vOUo6bhTUntl6pyJOJnVJBERGpIfkk+Q5YO4edDPwPQOKwxqVen0jyiucXJRKSqVJBERGpAQWkBQ5cN5ceDPwLQMLQhr/Z7lZZRLS1OJiLVoYIkInKWCl2FDP98OBv2bwCgfkh9Xr36VdpEt7E4mYhUV0AVJJfLxaJFi+jQoQMrVqw45dhNmzZx8803c8455xASEkKbNm0YMWIEWVlZ3gkrIn6huKyYkctH8s3ebwCIDI5k/lXzadugrcXJRORsBERBKi4uZu7cuSQkJDBo0CDS09NPOf7TTz+lW7duvP322+zfv5+SkhK2b9/OrFmz+NOf/sSGDRu8lFxEfFlpWSkPr3iYNXvWABAeFM68vvPoGNPR4mQicrYCoiAtX76czp07c8cdd5x2bHZ2NrfeeivdunXjgw8+ID09nRUrVnDddeV32T5w4AD/8z//Q0FBQW3HFhEfVuou5bFVj7Fy10oAwhxhzO07l/Mbn29xMhGpCQF1HaTs7GwaNWoElJemXr16nTBm4sSJbN68mUWLFmEYhme9aZrcfvvt/OMf/wDg1VdfrdKtAXQdJJG6o8xdxhNfPMEnzk8ACLGHMLfvXLo17WZxMhGpSNdBOgPR0dGnHfPNN98wd+7c48oRlN9M8qWXXsLhKL/4+Pr162slo4j4Nrfp5tk1z3rKUZAtiBm9Z6gcidQxAVWQfis3pzJhwgTCw8Mrfa5JkyZ06tQJgNDQ0BrNJiK+zzRNnlv7HB9u/RAAh83BS71e4ormV1icTERqWkAVpDNxunsihYSEANC5c2dvxBERH2GaJi98/QLvZbwHgN2wM7nnZBLjEi1OJiK1QQWpCkzTZOvWrYSEhPCXv/zF6jgi4iWmaTL126n885d/AmAzbLzQ4wX6tuprcTIRqS2n3+ckHuvWrSM7O5uRI0fSoEGDU47Nyso67ppJ+fn5AGzcuJGIiAjP+tjYWGJjY2snsIjUiJkbZrLop0UAGBg8f+XzXNP6GotTiUhtUkGqgmnTphEbG8uYMWNOO3bevHmMGzfuhPWJicdPx48ZM4axY8fWVEQRqWHzvp/HKz++4ll+9vJnGXDuAAsTiYg3qCCdobVr1/Luu+/y8ccfU79+/dOOv++++xgw4PcP0fz8fBITE1m5cuUJM0gi4psWbFrArI2zPMtPXPIE/9vufy1MJCLeooJ0Bo4ePUpKSgrPPfccV1999Rm9puKus9zcXAC6du2q6yCJ+IE3f36TF7970bP8yMWPcGvHWy1MJCLepIO0z8C9997L5ZdfzpNPPml1FBHxgnfS32HC1xM8yw9c8AB3dbrLwkQi4m2aQTqNsWPHUlhYyGuvvWZ1FBHxgvcz3uf5r573LN/X5T7u6XKPhYlExAoqSKcwf/58vvjiCz7++GPsdrvVcUSklv13238Zs+b3kzAGdx7MsK7DLEwkIlbRLraTWLhwIWlpaXzwwQeei0P+kcvl4t1337UgmYjUhsXOxTy1+ilMym9PeXvH2xl14agTbjskIoEhoApSUVGR5+fi4uKTjnvttdeYOHEir7/+OsXFxRw8eJCDBw9y4MABMjMzWbJkCf379z/lNkTEfyzfuZzRq0ZTZpYBcFO7m3is22MqRyIBLGB2sZmmyVtvveVZ/uijj+jVq9cJs0Nz585l2LBhmKZJu3btTrq9iIgI/v3vf9daXhHxjtW7V/PwyodxmS4A/pLwF5667CmVI5EAFxAzSO+88w4hISEMHjzYs2727NnUq1ePRx55xLPugw8+YOjQoZimedpt3nDDDSe9qa2I+Ievsr5i5PKRlLpLAbi29bWMvXwsNiMgPhpF5BQM80zagJy13NxcoqOjycnJ0XWQRHzAd/u+Y8jSIRS6CgG4qtVVTOo5CYctYCbWRQJCdb9/9c8kEQk43x/4nqFLh3rKUa8WvZjYY6LKkYh4qCCJSEDZnL2ZIUuGUOAqAODK5lcytddUguxBFicTEV+igiQiASP9UDr3LbmPvNI8AC5teinTek0j2B5scTIR8TUqSCISELYe2cq9S+4lpzgHgAubXMiMPjMIdYRanExEfJEKkojUec4cJymLUzhUdAiALo26MDtpNvWC6lmcTER8lQqSiNRpmXmZJC9O5mDhQQA6NuzI3KvmEhEcYXEyEfFlKkgiUmdl5WeR8lkK+wv2A9CuQTvmXzWfqGBdakNETk3ntIpInZKRkUFaWhoZWRlkXplJQXD52Wptotsw/6r51A+tb3FCEfEHKkgiUmcsWLCAlJQUHNEOWj3aipDg8lsJNTAb8OrVrxITFmNxQhHxF9rFJiJ1QkZGBikpKRhhBi0faklIs/JyVLK/hHWPrCNnT47FCUXEn6ggiUidkJaWhuEwaDmiJaFx5aful2SXsH3SdsqOlJGammpxQhHxJypIIlInbHduJ/bOWMI7lN9E2pXjwjnRSenBUkzTxOl0WhtQRPyKjkESkTqh7MIy6jcpPwDbXeJmx4wdlOwvAcAwDOLj4y1MJyL+RjNIIuL3FjsX80uTXzzLu17ZReHWQs+yaZokJydbEU1E/JRmkETEr/144EeeXP2kZ3n//+3n6Pqj2Gw2DMPANE1SU1NJSEiwMKWI+BsVJBHxW1n5WYz4fATFZcUADDh3AIOmDCLtvDScTifx8fEkJyerHIlIlRmmaZpWhwgEubm5REdHk5OTQ1SUruIrcrbyS/K589M7yTicAcBF51zE/KvmE2wPtjiZiPiS6n7/6hgkEfE7LreLR1c96ilHLSNbMq3XNJUjEakxKkgi4ncmfTOJ1btXAxAVHMWspFm6hYiI1CgVJBHxK2/+/Cb//OWfADgMB9N6T6N1dGuLU4lIXaOCJCJ+Y9WuVUz6ZpJn+dnLn6Vb024WJhKRukoFSUT8QvqhdB5d+Shu0w1Acudkbmh7g8WpRKSuUkESEZ93sPAgwz8fToGrAICrWl3FAxc+YHEqEanLVJBExKcVugoZsWwEe4/uBaBzTGf+1v1v2Ax9fIlI7dEnjIj4LLfp5qnVT7EpexMAseGxzEyaSZgjzOJkIlLXqSCJiM+asX4GS3YsAaCeox4z+8ykUVgji1OJSCBQQRIRn/R+xvukbkoFwGbYmJw4mfYN21ucSkQChQqSiPicr7O+5rm1z3mWR3cbTc8WPS1MJCKBRgVJRHyKM8fJqBWjcJkuAG7pcAu3drzV4lQiEmhUkETEZxwpOsKwZcPILckFoHvz7jzW7TGLU4lIIFJBEhGfUFJWwoPLH2Rn3k4A2jZoy+Sek3HYHBYnE5FApIIkIpYzTZNxa8exfv96AGJCY5jdZzYRwREWJxORQKWCJCKWe+XHV/hw64cAhNhDmNlnJrERsRanEpFApoIkIpb61PkpMzfM9Cz/vfvfOb/x+RYmEhFRQRIRC31/4Hue+uIpz/KDFz7I1fFXW5hIRKScCpKIWGJ3/m4e+PwBStwlAPwl4S8kd062OJWISDkVJBHxurySPIYvG86hokMAdGvajWcvexbDMCxOJiJSTgVJRLzK5Xbx6MpH2XJkCwCtolrxUq+XCLIHWZxMROR3Kkgi4jWmaTLh6wl8uedLAKJDopmdNJvokGiLk4mIHE8FSUS85s2f3+Tt9LcBcNgcTOs1jVZRrSxOJSJyIhUkEfGKlZkrmfztZM/yuCvGcXHTiy1MJCJycipIIlLr0g+l8+iqR3GbbgDuOf8eBpw7wOJUIiInp4IkIrXqQMEBhi0bRqGrEIB+8f0YfsFwi1OJiJyaCpKI1JqC0gKGfz6cfQX7AOjSqAvjrxyPzdBHj4j4Nn1KiUitcJtunlz9JD9l/wRAs/BmTO8znVBHqMXJREROTwVJRGrFtPXTWLZzGQDhQeHMSppFo7BGFqcSETkzKkgiUuPe+/U9FmxaAIDdsDM1cSptG7S1OJWIyJlTQRKRGrUuax3jvxrvWX7ikie4svmVFiYSEak6FSQRqTHbcrYxasUoXKYLgNs73s7ADgMtTiUiUnUBVZBcLheLFi2iQ4cOrFix4rTjt2zZwq233kpsbCyNGzdm4MCBbN26tfaDivihw0WHGbZ0GHkleQD0bNGTRy5+xOJUIiLVExAFqbi4mLlz55KQkMCgQYNIT08/7WsWL17MBRdcQL169UhPT8fpdBIVFcWFF17IunXrvJBaxH+UlJUwcvlIduXvAqB9g/ZM6jkJu81ucTIRkeoJiIK0fPlyOnfuzB133HFG47du3cqNN95IQkIC8+fPJyoqivDwcObOnUvTpk25/vrryc7OruXUIv7BNE3GrBnD+v3rAWgc1phZSbMIDwq3OJmISPUFREHq378/PXr0YOTIkWc0/qGHHiI/P5+hQ4dis/3+W+RwOLj//vs5cOAAo0ePrq24In5l3g/z+M+2/wAQag9lZtJMmoY3tTiViMjZcVgdwJuio6NPO2b79u18+OGHAPTt2/eE5/v16wfAG2+8wcSJE4mJianZkCI+LiMjg7S0NJxOJ0HnB7Gh+QYADAwm9JhAp5hOFicUETl7AVWQHI7T/+9+/PHHAISHh9O6desTnm/fvj2hoaEUFRXxwQcfkJycXOM5RXzVggULSElJwTAMQtuE0iqpFbZjE9GjLhpFUqskixOKiNSMgNjFVhWfffYZAHFxcZU+b7fbad68OQBff/2113KJWC0jI4OUlBTcbje2BjbiRsRhCyr/CDm88jDdQ7pbnFBEpOaoIFWwbds2AFq0aHHSMb/tVvvll1+8kknEF6SlpWEYBrYwG61GtcIRVT4jm/9TPnvf3EtaWprFCUVEak5A7WI7EwcOHAAgMjLypGNCQkIAOHz48EnHZGVlkZWV5VnOz88HYOPGjURERHjWx8bGEhsbe1aZRbzB6XRiGiZxQ+MIbV5+w9nirGJ2ztoJrvLnRUTqChWkCg4dOgRAvXr1TjrG7XYDUFRUdNIx8+bNY9y4cSesT0xMPG55zJgxjB07thpJRbyrVXwrYm+LJfL88n88uPJc7HhxB+4CN3a7nfj4eGsDiojUIBWkCoKDg3G5XKccU1paCkCDBg1OOua+++5jwIABnuX8/HwSExNZuXLlCTNIIv6gSf8mNHCW/5l3l7rZOXMnJQdKgPJrIemEBRGpS1SQKoiJiaGgoIDCwsKTjsnJyQGgUaNGJx1TcddZbm4uAF27diUqKqqG0op4x8rMlSx0LvQsZy3MomhLEXa7HdM0SU1NJSEhwbqAIiI1TAWpgo4dO5KZmcm+fftOOua3q2hXdhkAkbom/VA6j656FBMTgL+2+CuFPQpxxjmJj48nOTlZ5UhE6hwVpAq6d+/O4sWL2b59e6XPHz16lIMHDwJw1VVXeTOaiNcdKDjAsGXDKHSVz6j2i+/H0z2fxpakE2BFpG7Tp1wFN954IwB79uxh7969Jzz/448/AuXHKvXp08er2US8qdBVyIjPR7CvoHw2tUujLoy/cjw2Qx8bIlL36ZOugvPOO49rrrkGgE8++eSE55ctWwbAnXfeecpLAYj4M7fp5skvnmRz9mYAmoU3Y3qf6YQ6Qi1OJiLiHQFVkP54Wn5xcfFJx02bNo2wsDDmz59/3PqCggJSU1OJiYlh/PjxtZZTxGoz1s9g6c6lAIQHhTMraRaNwk5+UoKISF0TMAXJNE3eeustz/JHH3100pLUrl07FixYwLfffsvo0aMpLi4mKyuLm266iSNHjvDhhx9yzjnneCu6iFe9n/E+qZtSAbAZNqYkTqFtg7YWpxIR8a6AKEjvvPMOISEhDB482LNu9uzZ1KtXj0ceeaTS1wwcOJAVK1bw3Xff0axZMy6//HLi4+P56aefuOKKK7wVXcSrvtn7Dc999ZxneXS30XRvrnusiUjgMUzTNK0OEQhyc3OJjo4mJydH10ESn+TMcXLbx7eRW1J+za5bOtzCk5c+aXEqEZGzU93v34CYQRKRU8spzmH458M95ah78+481u0xi1OJiFhHBUkkwJWWlTJy+Uh25O4AIKF+ApN7TsZh02XSRCRwqSCJBDDTNHnuq+f4dt+3AMSExjA7aTYRwRGneaWISN1meUHavHkze/bssTqGSEBK25TGB1s+ACDEHsKMPjNoFtHM4lQiItazvCDl5eXRp08fevfuzauvvsqRI0esjiQSEJbsWMK09dM8y+O7j6dL4y4WJhIR8R2wBn7AAAAgAElEQVRVPott48aN5OXlHfeIjIxk4MCB1Q5RUlLCc889x4QJE3A4HPTr14/bbruNm266qdrb9DU6i018yeaDmxn06SCKysovnjrighHc2+Vei1OJiNS86n7/Vrkg2Ww2DMMAoHHjxtxwww1cf/31XHvttVVLXInFixdz4403cvToUQzDoKys7Ky36StUkMRX7D26l1v+ewsHC8tvujzg3AGMv3K85++1iEhdUt3v32qfpnLXXXfx8ssvExwcXN1NnODqq69m/vz53HbbbTW2TRH53dHSowxfNtxTji5sciFjLh+jciQiUkG1jkGKj49n/vz5lZajyy+/nNjYWOx2e6WPFi1a0Lt375Nu+5ZbbqFr167ViSUip1DmLuOxVY+RfjgdgLjIOKb1nkawveb+kSMiUldUqyBdffXVOByVTz6tXbuWrKwsFi9eTOPGjTFNE9M0SUlJYdeuXezatYvly5efcvv9+vWrTiwROYUp305h1a5VAEQGRzIraRYNQhtYnEpExDdVqyA1adLktGOSkpIYO3YsAH369GHevHnExsae0fZbtGhRnVgichLvpL/DGz+/AYDDcPBirxdpE93G4lQiIr6rWgUpJCTkjMZ1715+k8u//vWvVdp+eHh4lTOJSOXW7F7D39f93bP89GVPc1nsZRYmEhHxfbV6HaSGDRsC0KxZ1S48pwNGRWrG1iNbeXjlw5SZ5WeEDuo0iBvb3WhxKhER31erBclutwNnPuMkIjUnuzCbYcuGkV+aD0DvuN6MvHCkxalERPyD5VfSFpGaV1xWzIPLH2R3/m4AOjbsyIQeE7Db7BYnExHxDypIInWMaZo88+UzfH/gewCahDVhZp+Z1AuqZ3EyERH/4ZMFye12Wx1BxG+9/P3LfLL9EwDCHGHMTJrJOeHnWJxKRMS/+GRB2rVrl9URRPzSf7f9lznfzwHAwGBCjwmcF3OexalERPxPtW41smHDBl577bXTjsvJyQFgyZIl7N2797TjXS4XmZmZTJo0qTqxRALaxv0beebLZzzLD130EH1a9rEwkYiI/zqrm9WeCdM0q3za/m+v0c1qRc7Mrrxd3PbxbRwqOgTAjW1v1D3WRESw4Ga1Z9qrfvuArup4ETkzeSV5DF823FOOLm16KU9d9pT+LomInIVqF6QzVcUJqiqPFwlkpe5SHl7xMFtztgIQHxXP1F5TCbIFWZxMRMS/VasgtWjRgptvvplWrVpRr169GvmXqmmaFBcXs3v3bhYuXMju3bvPepsidZlpmkxYN4G1WWsBqB9SnzlJc4gOibY4mYiI/6tyQbLb7XzyySecd17tnRkzePBg2rdvX2vbF6kL3vj5Dd759R0AHDYH03pPIy4qzuJUIiJ1Q5VP82/Tpk2tliOA1q1b07Nnz1r9NUT82crMlUz+ZrJnedwV47jonIssTCQiUrdUuSBV9caz1RUbG+uVX0fE36QfSufRVY9iUn683r1d7mXAuQMsTiUiUrdUuSCdyfWPasLkyZNPP0gkwBwoOMCwZcModBUC0C++H8O6DrM4lYhI3VPlghQX551jHJo2beqVX0fEXxS6Chnx+Qj2FewDoEujLoy/cjw2wycviC8i4tf0ySriB9ymmye/eJLN2ZsBiA2PZXqf6YQ6Qi1OJiJSN6kgifiBGetnsHTnUgDCg8KZlTSLRmGNLE4lIlJ3qSCJ+Lj3M94ndVMqADbDxuSek2nXoJ3FqURE6rZav5K2iFRdRkYGaWlpbMrdxI5uO+DYtVhHdxtNjxY9rA0nIhIAVJBEfMyCBQtISUkhpGkI8U/GYzfsAHQ1u3Jrx1stTiciEhi0i03Eh2RkZJCSkoIRZtDigRbYI8rLUd73efzjnn+wZcsWixOKiAQGFSQRH5KWlobhMGg5oiUhTUMAKMosInNuJoZpkJqaanFCEZHAoIIk4kO2O7cTe2cs4R3CAXDluNgxbQfuIjemaeJ0Oq0NKCISIHQMkogPcV3kon7j+gC4S9zsmL6D0uxSAAzDID4+3sJ0IiKBQzNIIj7i0+2fkt443bO8a/4uCrcVepZN0yQ5OdmKaCIiAUczSCI+YOP+jTy1+inP8r5393F0w1FsNhuGYWCaJqmpqSQkJFiYUkQkcKggiVgsMy+TB5c/SIm7BIAbEm7gjhfvIK1zGk6nk/j4eJKTk1WORES8yDBN07Q6RCDIzc0lOjqanJwcoqKirI4jPiK3JJc7Pr6DbTnbALik6SW83PdlguxBFicTEakbqvv9q2OQRCxS6i7loRUPecpRfFQ8L/Z6UeVIRMQHqCCJWMA0Tf721d9Yl7UOgAYhDZiTNIfokGiLk4mICKggiVhi4eaFvJfxHgBBtiCm95lOXFScxalEROQ3KkgiXrZ0x1Je+u4lz/LzVz7PBU0usDCRiIhUpIIk4kWbDm7iiS+ewKT83IihXYdyXZvrLE4lIiIVqSCJeElWfhYjPh9BUVkRAH9u82fu73K/xalERKQyKkgiXpBfks+wz4dxsPAgABc2uZBxV4zDMAyLk4mISGVUkERqmcvt4pFVj5BxOAOAlpEtmd57OsH2YIuTiYjIyaggidQi0zSZ8PUEvtz9JQBRwVHMTppN/dD6FicTEZFTUUE6hQMHDvDwww/Ttm1bIiIiiI6Opnv37ixatAhdgFzOxJs/v8nb6W8D4LA5mNZ7GvHR8daGEhGR01JBOoktW7bQtWtXPv74Y1599VUOHz7Mnj17GDRoEEOGDOHWW29VSZJTWpG5gknfTPIsj718LN2adrMwkYiInCndrPYk7rzzTrKzs1m9ejWtW7cGICgoiJSUFPbu3cszzzzD1VdfzeDBgy1OKr7o5+yfeWzVY57T+e85/x7+J+F/LE4lIiJnSjNIldi6dStr166lU6dOnnL0R/369QPggw8+8HY08QP7ju5j+OfDKXQVAtA/vj/DLxhucSoREakKFaRKHDxYfip2VlYWbrf7hOdDQ0MBCA8P92ou8X0FpQWM+HwE+wv2A9ClcReev/J5bIb+qomI+BN9alciISEBh8NBVlYWixYtOuH5r776CoA77rjD29HEh5W5yxi9ajQ/H/oZgOYRzZnRewahjlCLk4mISFWpIFUiJiaGgQMHAjBs2DA+++wzz3M5OTlMmDCB++67j2uuucaqiOKDpn43lRW7VgAQGRTJ7KTZxITFWBtKRESqRQXpJGbMmEGHDh0oLCzkuuuuY/bs2RQUFHDjjTcyaNAg5s6da3VE8SFv//I2r//0OgAOw8HUXlM5t/65FqcSEZHqMkydq35Se/fupV+/fvzwww8ANG/enBdeeOGMdq1lZWWRlZXlWc7PzycxMZGVK1cSERHhWR8bG0tsbGzNhxevWb17NcOXDafMLANgzOVj+N92/2txKhERAcjNzSU6OpqcnByioqLO+HUqSKeRkZFBv379KCgoYN++fURHR/PWW2/Rv3//U75u7NixjBs37rTbHzNmDGPHjq2htOJtvx7+lTs/uZOjpUcBGNxpMA9d/JDFqURE5DcqSLVg/fr13Hbbbfzf//0f4eHh/PnPf+bHH3/EbreTlpbGnXfeedLXagap7jtYeJBb/3srWUfL3+e+LfsytddUnbEmIuJDVJBq2ObNm+nevTvPPfccI0aMAODIkSNcd911rFmzBrvdzpIlS+jdu/cZba+6b5D4pkJXIXd/ejebsjcB0CmmEwv6LyDMEWZxMhER+aPqfv/qn7onkZycTFFR0XFXyq5fvz6ffPIJXbt2payszFOcJLC4TTdPrX7KU46ahjdlZp+ZKkciInWIClIl1q9fz7p162jXrt1xu8MAoqKiePfddwkKCmLz5s1kZGRYlFKsMn39dJbsWAJAeFA4s5Nm07heY4tTiYhITVJBqsSvv/4KgMNR+a3qzj33XHr16gVAdna2t2KJD3jv1/dI25QGgM2wMbnnZNo1aGdxKhERqWkqSJVo1aoVUH4GW1lZWaVjQkNDsdlsJCQkeDOaWOirrK8Y/9V4z/ITlzxBjxY9LEwkIiK1RQWpEpdddhkXXngheXl5vPzyyyc8v2/fPlavXs3AgQNp1KiRBQnF27Yd2cZDyx/CZboAuL3j7dzc4WaLU4mISG1RQaqEYRi8/fbbxMXF8dhjj5GWlkZxcTEul4uvvvqKa6+9lrZt2+pq2gHiUNEhhi4bSl5pHgC9WvTikYsfsTiViIjUJp3mfwrZ2dlMmjSJf//73+zatYugoCDOPfdcbrnlFoYPH05ISMgZb0un+fun4rJiUj5LYeOBjQB0aNiBRf0XUS+onsXJRETkTOg6SD5OBcn/mKbJ6FWj+cT5CQBNwprw5nVv0jS8qcXJRETkTOk6SCI1bPbG2Z5yFOYIY1bSLJUjEZEAoYIkUokPt37IvB/mAWBgMKnnJDrGdLQ4lYiIeIsKkkgF3+79ljFrxniWH+32KL3ielkXSEREvE4FSeQPduTuYOSKkbjc5afzD2w/kNs73m5xKhER8TYVJJFjjhQdYdiyYeQU5wBwZfMrefySxzEMw+JkIiLibSpIIkBJWQkjV4xkR+4OANo2aMuUnlNw2Cq/3YyIiNRtKkgS8EzTZNzacXy37zsAYkJjmN1nNhHBEad5pYiI1FX657EEpIyMDNLS0nA6nZReVEp643QAQu2hzEqaRWxErMUJRUTESipIEnAWLFhASkoKhmEQeUkkLfq38Dz3Qo8X6Nyos4XpRETEF2gXmwSUjIwMUlJScLvdBLcOptndzTzP7XtnH/Gl8daFExERn6GCJAElLS0NwzAIahxEqwdaYQsq/ytwaOUhDn12iNTUVIsTioiIL1BBkoDidDqxhduIfzgeR1T5Hub8zfnseW0PpmnidDqtDSgiIj5BBUkCSlzrOOIeiCOkaQgARbuL2Dl7J5SBYRjEx8dbG1BERHyCDtKWgFHmLuPw5Yepd6geAKWHS9kxdQfuAjdQfrp/cnKylRFFRMRHqCBJwJjy7RS+OvQVAGVFZWROz6TsSBl2ux3TNElNTSUhIcHilCIi4gtUkCQgvLb5Nd74+Q0A7IadZy98lvU3r8fpdBIfH09ycrLKkYiIeKggSZ33mfMzJn872bM85vIx3ND2Bv7a7a8WphIREV+mg7SlTlu/bz1PfvGkZ3non4ZyQ9sbLEwkIiL+QAVJ6qxtOdsY8fkIStwlANyQcAP3/+l+i1OJiIg/UEGSOulg4UGGLh1KbkkuAFc2u5JnLn8GwzAsTiYiIv5ABUnqnILSAoYtG8bu/N0AdGjYgam9phJkC7I4mYiI+AsVJKlTXG4Xj6x8hJ+yfwIgNjyW2UmzCQ8KtziZiIj4ExUkqTNM02T8V+P5YvcXAEQGRTInaQ5N6jWxOJmIiPgbFSSpM1758RXey3gPgCBbENP7TCehga5tJCIiVaeCJHXCR1s/YuaGmZ7lv3X/G92adrMwkYiI+DMVJPF7a/es5dkvn/Usj7poFNe0vsbCRCIi4u9UkMSvpR9KZ9SKUbhMFwAD2w9kcKfBFqcSERF/p4Ikfmvv0b0MXTaUo6VHAegV14snLnlC1zoSEZGzpoIkfimvJI8hS4ewv2A/AOc3Op9JPSdht9ktTiYiInWBCpL4ndKyUkatGMWWI1sAaBHRgpl9ZhLmCLM4mYiI1BUqSOJXTNPk2TXPsi5rHQD1Q+rz8lUvExMWY3EyERGpS1SQxK/M3DCT/2z7DwAh9hBmJc2iVVQri1OJiEhdo4IkfuNfv/6LV358BQADg4k9JvKnxn+yOJWIiNRFKkjiF1btWsX4r8Z7lkdfMpqkVkkWJhIRkbpMBUl83uaDm3lk5SO4TTcAd513F7d1vM3iVCIiUpepIIlPy8zLZOiyoRS6CgHoF9+Phy5+yOJUIiJS16kgic86UnSEoUuHcqjoEAAXNrmQv3X/GzZDf2xFRKR26ZtGfFKRq4gHlj+AM9cJQOvo1szoM4MQe4i1wUREJCCoIInPcZtunlz9JBv2bwCgUVgj5vadS3RItMXJREQkUKggic+Z8u0UluxYAkCYI4zZSbNpHtHc4lQiIhJIVJDEp7z+0+u8/tPrANgNO1MTp3JezHkWpxIRkUCjgiQ+Y8mOJUz+ZrJn+ZnLnqFHix4WJhIRkUClgiQ+YcP+DTy+6nFMTADu7XIvN7a70eJUIiISqFSQxHLbc7Yz4vMRlLhLABhw7gCGdx1ucSoREQlkKkhiqYOFBxmydAg5xTkAXBZ7GWMvH4thGBYnExGRQKaCJJYpKC1g+LLh7M7fDUC7Bu14qddLBNmDLE4mIiKBTgVJLOFyu3hs1WNszt4MwDn1zmFO0hwigiMsTiYiIqKCJBYwTZO/r/s7K3etBCAiKII5fedwTvg5FicTEREpp4IkXpe6KZV//fovABw2B9N6T6Ndg3YWpxIREfmdCpJ41X+2/Yfp66d7lp+74jkujb3UwkQiIiInclgdwJ+UlJTw7rvv8tFHH7Fv3z5atmzJLbfcQr9+/ayO5hfWZa3jmS+f8Sw/cMEDXH/u9RYmEhERqZwK0hlasmQJ9913HzExMbz44ov06KErPFfFr4d/ZeTykbjcLgD+2u6vpJyfYnEqERGRymkX2xmYMGEC/fr1IykpiTVr1qgcVdHeo3sZunQo+aX5ACS2SOTJS5/UtY5ERMRnaQbpNCZNmsQTTzzBXXfdxSuvvGJ1HL+RkZFBWloaWzO3sqvHLvJC8wDoFNOJST0n4bDpj56IiPgufUudwr/+9S8ef/xxOnbsyLx586yO4zcWLFhASkoKhsMg7sE4IkLLr20UbUYzK2kW9YLqWZxQRETk1LSL7SQOHz7MkCFDME2TadOmERISYnUkv5CRkUFKSgput5umdzYlolN5OXLlu/juqe84svuIxQlFREROTwXpJMaNG0d2djZdunTh6quvtjqO30hLS8MwDJr8vyY06N4AAHepm53TdlK6r5TU1FSLE4qIiJyedrFVoqioiLS0NACuv/56ZsyYwb///W82bdpEaWkpF1xwAU899RR9+vQ56TaysrLIysryLOfnlx+gvHHjRiIifr+dRmxsLLGxsbX0f+J9TqeT6J7RNBnQBADTbbJr3i4KthRgs9lwOp3WBhQRETkDmkGqxOLFi8nLKz+o+KOPPqJ58+a8//77pKen88ADD7B8+XL69u17ytmQefPmcdFFF3keiYmJACQmJh63vq4d2xTWOYzYO34vfHv/uZfcb3MBMAyD+Ph4i5KJiIicOcM0TdPqEL7m0UcfZcqUKYSEhJCXl0dQ0PF3lx82bBhz5swhODiYH374gfbt25+wjcpmkBITE1m5cmWdnUH64cAPDP50MCXuEgAOfnKQvW/v9Txvs9lIT08nISHBqogiIhJgcnNziY6OJicnh6ioqDN+nXaxVWL37t1AeXmpWI4AHn74YebOnUtJSQlz585l2rRpJ4ypWHxyc8tnUbp27VqlN8hf7MjdwfBlwz3lKGddDgfeO4DNZsMwDEzTJDU1VeVIRET8ggpSJQ4ePAhAgwYNKn2+TZs2XHLJJaxbt461a9d6M5pPyi7MZsjSIRwuPgzAxedczGMjH+O16NdwOp3Ex8eTnJysciQiIn5DBakS9evXB8Dtdp90TLt27Vi3bh2HDx/2ViyfVFBawPBlw8nMywQgoX4C0/tMJyo4ihdeeMHidCIiItWjg7Qr0aZNG+D3XW2VadasGQAxMTFeyeSLXG4Xj656lE3ZmwBoUq8Jc/vOJSq47u1CFBGRwKKCVIn+/fsD5bvaMjIyKh3z28zRZZdd5rVcvsQ0TcZ/NZ5Vu1YBEBEUwdy+c2ka3tTiZCIiImdPBakSPXv2pEuXLgC89dZblY756aefMAyDu+++25vRfMa8H+bxXsZ7ADhsDqb3nk67Bu0sTiUiIlIzVJAqYbPZmD59Ona7nZkzZ7J3797jnl+7di2rV6/m/vvv5/zzz7copXU+2PIBszfO9iyPv3I8l8ReYmEiERGRmqWCdBK9evVizpw5HDx4kOuvv55ffvkFgC+//JKbb76Z6667junTp1uc0vu+3P0l49aM8yyPumgU17W5zsJEIiIiNU8F6RTuvfdeFi9eTGRkJBdffDGNGzfm4Ycf5umnn+ajjz6q9BpJddlP2T8xasUoXKYLgFs63MLgToMtTiUiIlLzdCVtL6nulTx9xa68Xdz+8e1kF2UDkNQyiamJU7Hb7BYnExERObnqfv9qBklO60jREYYsHeIpR10bd2VCjwkqRyIiUmepIMkpFbmKGPH5CJy5TgDio+KZ2WcmoY5Qa4OJiIjUIhUkOakydxmPf/E4Gw9sBCAmNIa5fedSP7S+xclERERqlwqSVMo0TSZ+M5FlO5cBUM9Rjzl959AisoXFyURERGqfCpJUauHmhfzzl38C4DAcvNjrRc6LOc/iVCIiIt6hgiQn+O+2//Lidy96lsdcMYYrm19pYSIRERHvUkGS46zLWsfTXz7tWR7WdRh/SfiLhYlERES8TwVJPNIPpTNy+Uhc7vILQd7Y9kbu63KfxalERES8TwVJANh7dC9Dlw0lvzQfgMQWiTx92dMYhmFxMhEREe9TQRJyS3IZsnQI+wv2A9A5pjOTek7CYXNYnExERMQaKkgBrqSshAc/f5AtR7YAEBcZx6ykWdQLqmdxMhEREeuoIAUwt+nmqdVP8e2+bwFoENKAl/u+TExYjMXJRERErKWCFMBe+u4lPnV+CkCoPZRZSbNoGdXS4lQiIiLWU0EKUG/+/CYLNy8EwGbYmJI4hS6Nu1gbSkRExEeoIAWgJTuWMPHriZ7lpy59isS4RAsTiYiI+BYVpADz3b7veHzV45iYANxz/j3c1P4mi1OJiIj4FhWkALLtyDYe+PwBStwlAAw4dwAjLhhhcSoRERHfo4IUIA4UHGDI0iHkluQCcEWzKxh7xVhdCFJERKQSKkgBIL8kn6HLhrLn6B4AOjTswIu9XiTIFmRxMhEREd+kglTHlZaV8tCKh/jl0C8ANAtvxpykOYQHhVucTERExHepINVhpmkydu1Y1matBSAqOIq5fefSuF5ji5OJiIj4NhWkOmzmhpl8uPVDAIJtwcxKmkWb+m0sTiUiIuL7VJDqqHfS3+GVH18BwMBgYs+JXNDkAotTiYiI+AcVpDpo+c7l/G3d3zzLoy8ZTd9WfS1MJCIi4l9UkOqYHw78wGOrHsNtugEY1GkQt3W8zeJUIiIi/kUFqQ7ZkbuD4cuGU1RWBMA18dcw6qJRFqcSERHxPypIdUR2YTZDlg7hcPFhAC5pegnju4/HZugtFhERqSqH1QGk+jIyMkhLS2Nb5jZ2d99NTlgOAAn1E3ip90sE24MtTigiIuKfVJD81IIFC0hJScGwG7QY3oLIsEgAIswI5vadS1RwlMUJRURE/Jf2v/ihjIwMUlJScLvdnHPbOUT+qbwclRWU8f2z35OflW9xQhEREf+mguSH0tLSMAyDxgMa07BXQwDcpW52zthJyZ4SUlNTLU4oIiLi31SQ/JDT6cTewE7jP/9+y5Ddr+7m6C9HMU0Tp9NpXTgREZE6QAXJD8XHx1N2uAznFCeufBdZb2WRs678AG3DMIiPj7c2oIiIiJ8zTNM0rQ4RCHJzc4mOjiYnJ4eoqLM7gDojI4MOHTrgdrtxRDtw5bg8z9lsNtLT00lISDjbyCIiIn6vut+/mkHyQ23btiU1NRWbzYaZb2Kz2bDb7dhsNlJTU1WOREREzpJmkLykJmeQfrNlyxZSU1NxOp3Ex8eTnJysciQiIvIH1f3+VUHyktooSCIiInJq2sUmIiIiUkNUkEREREQqUEESERERqUAFSURERKQCFSQRERGRClSQLJCVlcXYsWPJysqyOop4kd73wKT3PXDpvfdvKkgWyMrKYty4cfpLE2D0vgcmve+BS++9f1NBEhEREalABUlERESkAofVAQLFbxcsz83NJT8/H4D8/Hxyc3OtjCVepPc9MOl9D1x6733Db7/3Vb1xiG414iW7du0iLi7O6hgiIiIBKTMzkxYtWpzxeBUkL3G73ezZs4fIyEi+//57EhMTWblyJV27drU6mnjJxo0b9b4HIL3vgUvvvW8wTZO8vDyaNWuGzXbmRxZpF5uX2Gw2T3ONiIjw/Fc3rg0cet8Dk973wKX33ndER0dX+TU6SFtERESkAhUkERERkQrsY8eOHWt1iEAUERFBr169iIyMtDqKeJHe98Ck9z1w6b33XzpIW0RERKQC7WITERERqUAFSURERKQCFSQRERGRClSQRERERCpQQfKSTZs2cfPNN3POOecQEhJCmzZtGDFiBFlZWVZHEy974YUXMAyDhQsXWh1FvKSkpIR//OMf3HLLLfTp04dBgwbx2WefWR1LasGBAwd4+OGHadu2LREREURHR9O9e/f/3969R0Vd5n8Afw9XFeQiopEmooCSqYnkLQIMDULF6znumqsGLl7SjkUn11u2uLWEndVAvGQq6Bq4knLWVSENvCBIomhJgqil4UIrswrIVZjn9wc/vzHDAEPLzJfL+3XOnPMM3+f7PJ/hHODD97khNja21WeBkby4is0AkpKSMHPmTFRVVTW6Zm9vj+TkZIwaNUqGyMjQrl69irFjx6Kmpgb79u3DokWL5A6J9OzUqVNYsmQJ7Ozs8Le//Q2vvPKK3CGRnty6dQve3t6wsrLCzp07MWHCBNTU1CAuLg5vv/02pk+fji+//BIKhULuUEkHfIKkZ0qlEvPmzcNLL72ExMRE5OXl4cyZM5gyZQqA+v82pk+fjoqKCpkjJX2rqqrC/Pnz8eTJE7lDIQMJDw+Hn58ffH19kZ6ezuSok1uwYAGUSiVOnDgBb29vmJqawsLCAosXL8batWsRHx/PJ8cdCBMkPfviiy8wdepUnD17FtOnT4erqyu8vb1x7NgxzJs3D0D9CcNxcXEyR0r6tmbNGri4uGDAgAFyh0IGEOFKDJMAABUGSURBVBERgTVr1mDBggXYvXs3TE1N5Q6J9Oj27dvIyMjAsGHD4OTk1Oi6n58fACAxMdHQodFvxARJzy5duoQdO3Y0eqSqUCiwZcsWmJjUnxd85coVOcIjA0lJScGhQ4ewe/duuUMhAzh8+DD+9Kc/wc3NDbt27ZI7HDKA4uJiAEBhYSFUKlWj6926dQMAWFhYGDQu+u2YIOlZeHh4kz8Qffr0wbBhwwD8+sNDnc+jR4/w5ptv4osvvkDv3r3lDof07OHDh1i2bBmEENi6dSvMzc3lDokMwNnZGSYmJigsLERsbGyj6xcvXgQA/OEPfzB0aPQbMUHSM2dn52avP/3l+cILLxgiHJLBW2+9halTpyIgIEDuUMgA/vznP0OpVGLEiBF47bXX5A6HDMTOzg5z584FUP8z33CVYklJCcLDw7FkyRK8/vrrcoVIrcQESUZCCNy+fRvm5uaYMWOG3OGQHhw+fBiXL1/G5s2b5Q6FDKCqqgp79+4FAEybNg2RkZHw9fVF37590atXL/j6+iIlJUXmKElfIiMjMXToUFRWVmLKlCmIjo5GRUUFZs+ejUWLFmHHjh1yh0itwARJRpmZmVAqlVi2bBlsbW3lDofa2L///W+sXLkSf//739GjRw+5wyED+Prrr1FWVgYAOHbsGPr164ejR48iLy8Pb7/9NlJTUzFp0iTs2bNH5khJH3r16oXU1FSMGDECdXV1WLFiBVxdXbFw4UJs2LCBy/s7GCZIMtq6dSscHBywceNGuUMhPQgKCsKKFSvg4eEhdyhkIOfPnwdQP3SelZWF2bNnw8rKCjY2Nvjwww+luUnLly9HXl6ezNGSPjzzzDNISEiAk5MT+vbti/v372PlypVISkqSOzRqJSZIMsnIyEBCQgJiYmJgY2MjdzjUxrZt24aysjKsWbNG7lDIgO7fvw8AcHBw0LqsPzQ0FAqFAjU1NRxu6aSuXLmCwMBAHD9+HN9++y2GDx+OkpISTJ06Ffv375c7PGoFJkgyKC8vx+LFixEWFsZJnJ1QXl4eNm3ahAMHDsDY2FjucMiAni71bmrIfNCgQRgzZgyA+n+SqHPJycmBr68vli9fDjc3NwwYMADnzp3DhAkTUFdXh6CgIKSmpsodJumICZIMQkJCMH78eKxdu1buUEgPPv30U2kVk6WlZaPXvXv3AABLly6FpaWltNUDdXxPnwZr2wfnKVdXVwD12wFQ5xIcHIyqqiq8+eab0tdsbGxw8uRJvPjii6irq8PKlStljJBagwmSgX344YeorKzk5nGd2JMnT1BXV4fy8nKtr6fHH1ZXV0tfo85h0KBBAH4datPm2WefBVC/LJw6jytXriAzMxOurq6wtLRUu2ZlZYWEhASYmpoiJycH+fn5MkVJrcEEyYA+//xznD9/HnFxcRx66cRiYmIghGjy5ejoCADYt28fhBD46aef5A2Y2oy/vz+A+qG2pv4IPn1yNG7cOIPFRfp38+ZNAJBOR9A0ePBg+Pj4AKg/o5PaPyZIBhITE4O9e/ciMTFR6866tbW1SEhIkCEyImorXl5eGDFiBAAgPj5ea50ffvgBCoUCQUFBhgyN9OzpPz75+fmoq6vTWqdbt24wMjJqcQNhah+YIBnA/v378cknn+DAgQOorq5GcXExiouL8eDBA/z88884deoU/P39UV1dLXeoRPQ/MDIywmeffQZjY2NERUWhqKhI7XpGRgbS0tKwdOlSDB8+XKYoSR/GjRsHd3d3lJWVYefOnY2u//LLL0hLS8PcuXN55FBHIUivtm/fLhQKhQDQ7MvS0lI8fvxY7nDJABwdHQUAsW/fPrlDIT3ZtWuXUCgUwsPDQ9y4cUMIIURaWpoYMGCAmDJliqipqZE5QtKH/Px88dxzz4kePXqIPXv2iKqqKvHkyRORkZEh3N3dxZgxY8SjR4/kDpN0xCdIepSYmIjly5dLk3KbM3PmTJ7yTNRJhISE4Ouvv0bPnj3h4eEBe3t7hIaGYv369Th27JjWPZKo43N2dkZ2djZWrFiBiIgI2NnZwd7eHitWrMC8efNw7tw5WFtbyx0m6UghdPnrTURERNSF8AkSERERkQYmSEREREQamCARERERaWCCRERERKSBCRIRERGRBiZIRERERBqYIBERERFpYIJEREREpIEJEhEREZEGJkhEREREGpggEVG7U1paim3btsHNzQ0+Pj5yh6M3tbW1OHToUJu1d+LECSiVyjZrj6grY4JERO3G9evXsXz5cvTr1w8rV65Ebm6u3CHpzTfffINRo0bh7t27bdamQqHAqFGjsGfPnjZrk6irMpE7ACIiADhz5gw+/vhjmJmZ4fHjx3KHo1cRERGIiorCl19+iVdeeaXN2n399deRlJSEgIAAJCcnY+/evbC0tGyz9om6EoUQQsgdBBFRQ97e3jh37pxUPnPmjLwBtaHFixcjPj4eFy5cwMiRI/XSR35+Pjw9PeHk5ISTJ0/C1tZWL/0QdWYcYiOidmfEiBFyh6AX77//Pvbu3YsDBw7oLTkCABcXFxw9ehRZWVkIDAxEdXW13voi6qyYIBFRu9MZh4X27NmDzZs3Y+HChZg5c6be+5swYQJWr16NtLQ0LFmyRO/9EXU2TJCIqN0xNTWVO4Q2dffuXbzzzjswNTXFpk2bDNbvunXr0LdvX8TGxrbpajmiroAJEhG1O0ZGnetXU3BwMMrKyjB79mz079/fYP326NED7733HgDgrbfeQklJicH6JuroOtdvISKidiY5ORnffPMNAOCNN94weP8LFy6EkZERlEolPvroI4P3T9RRMUEiItKjsLAwAED37t3x2muvGbx/e3t7jBkzBgAQHR2Nhw8fGjwGoo6I+yARUaehUqmQmZmJ7OxsPHr0CL1798bgwYPh5eX1m+Y1lZWV4ezZs7h9+zbKy8vRp08fjB07FsOHD9fp/rS0NKSnpwMAxo8fDzMzs1bHkJubi6ysLBQVFaG6uhpWVlZwdnaGp6cnevbsqVMbXl5euHjxIioqKrB79268//77rY6DqKthgkREHZ5KpcKOHTsQHh6OgoIC2NjYQKVSobS0FABga2uLZcuWYcOGDejWrVuL7VVUVGDDhg3YsWMHKisrYWdnh9raWmkOz+jRo7F582a4ublJ9ygUCtjY2MDc3Fz6WlxcnFR2d3dv1Wf6xz/+gbCwMOTk5EifobKyElVVVQAAc3NzBAcH469//SusrKyabcvDw0Mq79+/nwkSkS4EEVE7s3HjRgFAABDe3t7N1i0tLRWvvvqqACA8PT1FVlaWdO3SpUtiwoQJUltDhw4VBQUFzbZXXFwsRo4cKQAIFxcXkZGRIYQQQqVSiaSkJNG3b1+pPc3XjBkzpHbq6urEM888I13bvXu3zp8/JCREui8wMFDcuXNHCCFETU2N2Lp1qzA2Npauv/zyy0KlUjXb3rVr19TivHHjhs6xEHVVTJCIqN3RNUGqra2VkqPRo0eLysrKRnWqqqqEl5eX1J6rq6soLi5uss2JEycKAMLU1FTk5+c3un7x4kW1BGXVqlXi5MmTIikpSeTl5Un1Ll++rJaUnDt3TqfPHhMTI93j7u4unjx50qjO+vXr1drWFmdDpaWlavUjIyN1ioWoK+MkbSLqsLZs2YKUlBQAwKeffqp1+Mzc3BwxMTHStZs3b2LlypVa2zt69ChSU1MBAL6+vnB2dm5UZ+zYsQgMDJTenzlzBv7+/vDz84Orq6v09StXrqjd5+LiotNniomJkcrBwcEwMWk8E2LdunV44YUXAABubm4YMGBAs2327NkTdnZ20vsLFy7oFAtRV8YEiYg6pNLSUvzlL38BUL9Sy9vbu8m6Tk5OartJx8XF4fLly43qNZwz9DQB0abhTthXr15FUVFRozqaCVLDBKU5v/zyi1QeOHCg1jrdunXDxYsXcerUKWRmZuo0+dvR0VEqX79+XadYiLoyJkhE1CHFxsZKk6Y9PT2hUCiarb9o0SK199u3b29U58aNG1K54WRrTcOGDVN7f/fu3UZ17ty5I5XNzMx0XkX3/PPPS+Wff/65yXoWFhaYNGmSzivZGta7c+cOBM8pJ2oWEyQi6pCOHDkilfv06dNi/RdffFGt3unTpxvVabiD93//+98m29JcNaZtGKzhrtWtOVtu7dq1MDY2BlB/fltdXZ3O9zanR48eUrmyshKPHz9uk3aJOismSESkFzExMVAoFC2+fHx8Wt22SqXCt99+K723sbHR6b5Ro0ZJ5Xv37qG8vFztesN5QlevXm2ynYbJhYmJida5So8ePZLKFhYWOsUH1G8HcPz4cdja2uLSpUuYOHEijh07hps3b6KoqAhFRUW/6ciQhgmS5mcgosaYIBFRh1NcXIyKigrpfXV1tU73NZyHAwBKpVLt/e9//3upnJmZqTZM1lDD+UUBAQGwtrZuVKe2trbV8T3l5+eHO3fuICgoCOfPn0dgYCCGDBkCBwcHODg4wMbGBqdOnWpVm927d1d739KQJFFXx40iiajD0Rx20vX4DM2hMc1VbzNmzMDLL7+MCxcuQKVSYfny5Th+/Lg05AUANTU1iIyMBFA/dPbJJ59o7avhU6OGyZwuLly4gA8++AApKSlwcHDAkiVLMHToUCkRs7CwwIQJE1rV5tMNJp/SltQR0a+YIBGRXixatKjRxOi2orkiLC8vT6f7GiZEPXv2hL29vdp1Y2NjHDlyBP7+/sjOzkZycjICAgKwbt06ODk5IS8vDxs3bsS1a9dgbW2NhIQEDB06tMUYKysrdf1o2LRpEzZu3AghBIYNG4b09PQWd8rWRcMhNTMzs0ZPlIhIHYfYiKjDMTMzUzvm47vvvtNpGKvhnKPx48drHWbq06cPMjMz4eHhAWdnZ6SmpsLb2xsDBgzA5MmT8d1332HRokXIzs7GpEmTmuxr0KBBUrmurq7RExxtDh8+jA8++EBaYfbRRx+1SXIEqCdI/fv3b5M2iTozPkEiog7Jz89PWpZfUVGB1NRU+Pv7N3tPQUGBVJ49e7bWOkIIrFq1CpaWlkhPT0dlZSVyc3NRXl6O3r17w83NTeuqNU0NEzgAuH//PgYPHtzsPZpbDzQ8Q00bpVKJ8vLyFjeKBNRX1TWcrE5E2vEJEhG1Ow336Glqv56lS5eqPQHauXNni+1+//33AOoPfp03b57WOqGhodi+fTuioqJgamoKKysrjBkzBhMnTsTw4cN1So4ANJoj9OOPP7Z4T2Fhodr75rYvSE1NRf/+/TFw4EBERUW12HbD/pkgEbWMCRIRtTulpaVSuanl6EOGDEFISIj0/p///CeysrKabPOHH35Abm4uAGD9+vVa9yZKT0/Hli1bAEDnDRibMnr0aLXhMV0SJM2dsxs+8dK0fv16VFVVQQiBXbt2Ndvu/fv31b6PEydObDEWoq6OQ2xE1O6kp6dL5dzcXBQUFGidNxMREYG0tDTk5ORACIEFCxbgwoULsLW1VatXV1eHd999FwAwadIkrFq1Smu/X331lVT28PDAlClT8Oyzz8LMzAwKhQJGRkYwNjaGmZkZLCws0K9fP/j4+GidJ2Rqaopp06bh4MGDAIBbt261+LmDgoKQnJysFs97773XqF5OTo7a9+i5555rtt2bN29K5f79+2P8+PEtxkLU5cl3Ti4R0a9KS0tFdHS0mDlzptrJ8wCEi4uL+Pjjj0Vqamqj+woKCoSrq6tU9/nnnxenT58WKpVKCCHErVu3xLRp0wQA4efnJ8rKypqMITY2tlHfLb1MTU3FsmXLREVFRaP2Tpw4IdXz9fXV6fsQFBQk3WNlZSWys7PVrtfW1go/Pz+pjomJiTh79myzbUZGRkr133nnHZ3iIOrqmCARUbuQn5/fYjLyxhtvaL23vLxcvPvuu6Jnz55S3e7duwt7e3sBQDg6OoqdO3dKSVNzoqKihLm5easTJW0JkEqlEkOGDBEAhIWFhaipqdHpe/HZZ58JW1tbAUCYm5uLoKAgsX37dhERESFGjRol9dmnTx/xr3/9q8X25syZIwAIY2Njcfv2bZ1iIOrqFELwxEIi6hwqKyuRkpKCn376CSUlJejVqxfc3d3x0ksv6bxz9LFjx/DHP/4R8fHxqKioQHFxMUpLS1FRUYGamhrU1dVJy/aVSiWuX7+OS5cuQQiBU6dONVr6v2/fPgQFBQEAUlJSdJ7/U1JSgvj4eBw/fhxXr17Ff/7zHwghYGdnh5EjR2LatGlYsGBBi+e8PXnyBH379sXDhw+xYMECxMbG6tQ/UVfHBImI6P+lpaVh8uTJOHjwIGbNmqXzfUeOHMHs2bMRHh6O1atXq11TqVRwd3fHtWvXEBIS0uKE6rZ28uRJBAQEwNzcHN9//73aeXNE1DSuYiMiQv0S+1mzZmHEiBGtSo4AYNasWejVq5fWpzlGRkb4/PPPYWJiggMHDjRayq9v27ZtAwCEhYUxOSJqBSZIREQAQkJC8ODBA0yePLnV9z548AAlJSXw8fHRen3MmDHYsGEDKisrERYW9j9GqrusrCycPHkS48aNQ2hoqMH6JeoMOMRGRF1ebm6utPP13LlzER8f36r7g4ODoVQqkZiY2GQdIQR+97vf4fDhwzh9+jReffXV/ynmllRVVcHT0xNKpRLp6elwcHDQa39EnQ33QSKiLk+pVErlQ4cOoX///ti4cWOLm0VWVFQgNDQUZ86cUduXSBuFQoHY2FhUV1dj/vz5SEtLUzuvra0FBwfj3r17SEtLY3JE9BvwCRIREYA5c+aobRRpY2ODwMBAeHp6wtXVFdbW1jA1NcXjx4/x448/IiMjA4cOHcLAgQORkJCg8wGwKpUKq1atwvHjx5GamqrTOWqtoVKpsHr1aiQnJyMxMVGvSRhRZ8YEiYgI9YlFZGQkwsLC8PDhwxbr29jYYNWqVVizZg3MzMxa3d/BgwcRHh6O6OhoeHl5/ZaQGyksLMT8+fPh6OiIqKgoWFhYtEm7RF0REyQiogYeP36Mr776CklJScjOzkZhYSHKy8thbW0Ne3t7jB49Gr6+vpgzZ47WI0Za4+HDh4iOjsb69evbJPZdu3bBw8MDo0ePbpP2iLoyJkhEREREGrjMn4iIiEgDEyQiIiIiDUyQiIiIiDQwQSIiIiLSwASJiIiISAMTJCIiIiINTJCIiIiINDBBIiIiItLABImIiIhIw/8BwpvYJuIBWScAAAAASUVORK5CYII=",
      "text/plain": [
       "PyPlot.Figure(PyObject <Figure size 600x400 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(6,4))\n",
    "plot_linear_regions(x, Es; tol = 0.8)\n",
    "xlabel(\"-log(ε)\"); ylabel(\"E\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the color schemes allow us to visualize that adjusting the tolerance reduces our number of linear regimes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `generalized_dim` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's summarize what we just did to estimate the dimension of an attractor.\n",
    "\n",
    "1. We decided on some partition sizes `ες` to use (the function `estimate_boxsizes` can give an estimate for that).\n",
    "2. For each `ε` in `ες` we calculated the entropy via `genentropy`. We stored these entropies in an array `Es`.\n",
    "3. We tried to find a \"linear scaling region\" of the curve `Es` vs. `-log.(ες)`.\n",
    "4. The slope of this \"linear scaling region\" is the dimension we estimated.\n",
    "\n",
    "Wouldn't it be **cool** if all of this process could happen with one function call?\n",
    "\n",
    "This is *exactly* what the following function does:\n",
    "```julia\n",
    "generalized_dim(α, dataset, ες = estimate_boxsizes(tr))\n",
    "```\n",
    "which computes the `α`-order generalized dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.9120149473639927"
      ],
      "text/plain": [
       "1.9120149473639927"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generalized_dim(2.0, tr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.045143523958735"
      ],
      "text/plain": [
       "2.045143523958735"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generalized_dim(1.0, tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first input to `generalized_dim` is our value for $\\alpha$!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, let's calculate the dimension of the Henon map that we have seen in previous tutorials,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.2192730981829056"
      ],
      "text/plain": [
       "1.2192730981829056"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hen = Systems.henon()\n",
    "tr = trajectory(hen, 200000)\n",
    "generalized_dim(0, tr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and of the Lorenz system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "lor = Systems.lorenz()\n",
    "tr_lor = trajectory(lor, 1000.0; dt = 0.05);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.9899579669996978"
      ],
      "text/plain": [
       "1.9899579669996978"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generalized_dim(2.0, tr_lor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correlation dimension of the Lorenz attractor (for default parameters) is reported *somewhere* around `2.0` (Grassberger and Procaccia, 1983).\n",
    "\n",
    "## `generalized_dim` is but a crude estimate!\n",
    "\n",
    "**It is important to understand that `generalized_dim` is only a crude estimate! You must check and double-check and triple-check if you want more accuracy!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other related concepts\n",
    "## Kaplan-Yorke dimension\n",
    "The Kaplan-Yorke dimension is defined as simply the (interpolated) number where the sum of Lyapunov exponents crosses zero.\n",
    "\n",
    "This simple interpolation is done by the function `kaplanyorke_dim(ls)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       "   0.900914  \n",
       "  -8.89309e-5\n",
       " -14.5675    "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lor = Systems.lorenz()\n",
    "\n",
    "ls = lyapunovs(lor, 4000.0; Ttr = 100.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2.0618380242828573"
      ],
      "text/plain": [
       "2.0618380242828573"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kaplanyorke_dim(ls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permutation Entropy\n",
    "\n",
    "Another entropy-like quantity that you can compute with **DynamicalSystems.jl** is the [permutation entropy](https://juliadynamics.github.io/DynamicalSystems.jl/latest/chaos/entropies/#permutation-entropy).\n",
    "\n",
    "This is done with the function `permentropy(s, order; ...)`. The permutation entropy is different because it requires a *timeseries* `s` as the input. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3.600068724233908"
      ],
      "text/plain": [
       "3.600068724233908"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create timeseries:\n",
    "s = (ds = Systems.towel(); trajectory(towel, 10000)[:, 1])\n",
    "# order `o` permutation entropy:\n",
    "o = 6\n",
    "permentropy(s, o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mg\u001b[22m\u001b[1me\u001b[22m\u001b[1mn\u001b[22m\u001b[1me\u001b[22m\u001b[1mn\u001b[22m\u001b[1mt\u001b[22m\u001b[1mr\u001b[22m\u001b[1mo\u001b[22m\u001b[1mp\u001b[22m\u001b[1my\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "genentropy(α, ε, dataset::AbstractDataset; base = e)\n",
       "```\n",
       "\n",
       "Compute the `α` order generalized (Rényi) entropy [1] of a dataset, by first partitioning it into boxes of length `ε` using [`non0hist`](@ref).\n",
       "\n",
       "```julia\n",
       "genentropy(α, p::AbstractArray; base = e)\n",
       "```\n",
       "\n",
       "Compute the entropy of an array `p` directly, assuming that `p` is sum-normalized.\n",
       "\n",
       "Optionally use `base` for the logarithms.\n",
       "\n",
       "## Description\n",
       "\n",
       "Let $p$ be an array of probabilities (summing to 1). Then the Rényi entropy is\n",
       "\n",
       "$$\n",
       "R_\\alpha(p) = \\frac{1}{1-\\alpha} \\log \\left(\\sum_i p[i]^\\alpha\\right)\n",
       "$$\n",
       "\n",
       "and generalizes other known entropies, like e.g. the information entropy ($\\alpha = 1$, see [2]), the maximum entropy ($\\alpha=0$, also known as Hartley entropy), or the correlation entropy ($\\alpha = 2$, also known as collision entropy).\n",
       "\n",
       "## References\n",
       "\n",
       "[1] : A. Rényi, *Proceedings of the fourth Berkeley Symposium on Mathematics, Statistics and Probability*, pp 547 (1960)\n",
       "\n",
       "[2] : C. E. Shannon, Bell Systems Technical Journal **27**, pp 379 (1948)\n"
      ],
      "text/plain": [
       "```\n",
       "genentropy(α, ε, dataset::AbstractDataset; base = e)\n",
       "```\n",
       "\n",
       "Compute the `α` order generalized (Rényi) entropy [1] of a dataset, by first partitioning it into boxes of length `ε` using [`non0hist`](@ref).\n",
       "\n",
       "```julia\n",
       "genentropy(α, p::AbstractArray; base = e)\n",
       "```\n",
       "\n",
       "Compute the entropy of an array `p` directly, assuming that `p` is sum-normalized.\n",
       "\n",
       "Optionally use `base` for the logarithms.\n",
       "\n",
       "## Description\n",
       "\n",
       "Let $p$ be an array of probabilities (summing to 1). Then the Rényi entropy is\n",
       "\n",
       "$$\n",
       "R_\\alpha(p) = \\frac{1}{1-\\alpha} \\log \\left(\\sum_i p[i]^\\alpha\\right)\n",
       "$$\n",
       "\n",
       "and generalizes other known entropies, like e.g. the information entropy ($\\alpha = 1$, see [2]), the maximum entropy ($\\alpha=0$, also known as Hartley entropy), or the correlation entropy ($\\alpha = 2$, also known as collision entropy).\n",
       "\n",
       "## References\n",
       "\n",
       "[1] : A. Rényi, *Proceedings of the fourth Berkeley Symposium on Mathematics, Statistics and Probability*, pp 547 (1960)\n",
       "\n",
       "[2] : C. E. Shannon, Bell Systems Technical Journal **27**, pp 379 (1948)\n"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?genentropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mg\u001b[22m\u001b[1me\u001b[22m\u001b[1mn\u001b[22m\u001b[1me\u001b[22m\u001b[1mr\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mi\u001b[22m\u001b[1mz\u001b[22m\u001b[1me\u001b[22m\u001b[1md\u001b[22m\u001b[1m_\u001b[22m\u001b[1md\u001b[22m\u001b[1mi\u001b[22m\u001b[1mm\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "generalized_dim(α, dataset [, sizes]) -> D_α\n",
       "```\n",
       "\n",
       "Return the `α` order generalized dimension of the `dataset`, by calculating the [`genentropy`](@ref) for each `ε ∈ sizes`.\n",
       "\n",
       "## Description\n",
       "\n",
       "The returned dimension is approximated by the (inverse) power law exponent of the scaling of the [`genentropy`](@ref) versus the box size `ε`, where `ε ∈ sizes`.\n",
       "\n",
       "Calling this function performs a lot of automated steps:\n",
       "\n",
       "1. A vector of box sizes is decided by calling `sizes = estimate_boxsizes(dataset)`, if `sizes` is not given.\n",
       "2. For each element of `sizes` the appropriate entropy is calculated, through `d = genentropy.(α, sizes, dataset)`. Let `x = -log.(sizes)`.\n",
       "3. The curve `d(x)` is decomposed into linear regions, using [`linear_regions`](@ref)`(x, d)`.\n",
       "4. The biggest linear region is chosen, and a fit for the slope of that region is performed using the function [`linear_region`](@ref). This slope is the return value of `generalized_dim`.\n",
       "\n",
       "By doing these steps one by one yourself, you can adjust the keyword arguments given to each of these function calls, refining the accuracy of the result.\n",
       "\n",
       "The following aliases are provided:\n",
       "\n",
       "  * α = 0 : `boxcounting_dim`, `capacity_dim`\n",
       "  * α = 1 : `information_dim`\n"
      ],
      "text/plain": [
       "```\n",
       "generalized_dim(α, dataset [, sizes]) -> D_α\n",
       "```\n",
       "\n",
       "Return the `α` order generalized dimension of the `dataset`, by calculating the [`genentropy`](@ref) for each `ε ∈ sizes`.\n",
       "\n",
       "## Description\n",
       "\n",
       "The returned dimension is approximated by the (inverse) power law exponent of the scaling of the [`genentropy`](@ref) versus the box size `ε`, where `ε ∈ sizes`.\n",
       "\n",
       "Calling this function performs a lot of automated steps:\n",
       "\n",
       "1. A vector of box sizes is decided by calling `sizes = estimate_boxsizes(dataset)`, if `sizes` is not given.\n",
       "2. For each element of `sizes` the appropriate entropy is calculated, through `d = genentropy.(α, sizes, dataset)`. Let `x = -log.(sizes)`.\n",
       "3. The curve `d(x)` is decomposed into linear regions, using [`linear_regions`](@ref)`(x, d)`.\n",
       "4. The biggest linear region is chosen, and a fit for the slope of that region is performed using the function [`linear_region`](@ref). This slope is the return value of `generalized_dim`.\n",
       "\n",
       "By doing these steps one by one yourself, you can adjust the keyword arguments given to each of these function calls, refining the accuracy of the result.\n",
       "\n",
       "The following aliases are provided:\n",
       "\n",
       "  * α = 0 : `boxcounting_dim`, `capacity_dim`\n",
       "  * α = 1 : `information_dim`\n"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?generalized_dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mn\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\u001b[1m0\u001b[22m\u001b[1mh\u001b[22m\u001b[1mi\u001b[22m\u001b[1ms\u001b[22m\u001b[1mt\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```julia\n",
       "non0hist(ε, dataset::AbstractDataset)\n",
       "```\n",
       "\n",
       "Partition a dataset into tabulated intervals (boxes) of size `ε` and return the sum-normalized histogram in an unordered 1D form, discarding all zero elements.\n",
       "\n",
       "## Performances Notes\n",
       "\n",
       "This method is effecient in both memory and speed, because it uses a dictionary to collect the information of bins with elements, while it completely disregards empty bins. This allows computation of entropies of high-dimensional datasets and with small box sizes `ε` without memory overflow.\n",
       "\n",
       "Use e.g. `fit(Histogram, ...)` from [`StatsBase`](http://juliastats.github.io/StatsBase.jl/stable/) if you wish to keep information about the edges of the binning as well as the zero elements.\n"
      ],
      "text/plain": [
       "```julia\n",
       "non0hist(ε, dataset::AbstractDataset)\n",
       "```\n",
       "\n",
       "Partition a dataset into tabulated intervals (boxes) of size `ε` and return the sum-normalized histogram in an unordered 1D form, discarding all zero elements.\n",
       "\n",
       "## Performances Notes\n",
       "\n",
       "This method is effecient in both memory and speed, because it uses a dictionary to collect the information of bins with elements, while it completely disregards empty bins. This allows computation of entropies of high-dimensional datasets and with small box sizes `ε` without memory overflow.\n",
       "\n",
       "Use e.g. `fit(Histogram, ...)` from [`StatsBase`](http://juliastats.github.io/StatsBase.jl/stable/) if you wish to keep information about the edges of the binning as well as the zero elements.\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?non0hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1me\u001b[22m\u001b[1ms\u001b[22m\u001b[1mt\u001b[22m\u001b[1mi\u001b[22m\u001b[1mm\u001b[22m\u001b[1ma\u001b[22m\u001b[1mt\u001b[22m\u001b[1me\u001b[22m\u001b[1m_\u001b[22m\u001b[1mb\u001b[22m\u001b[1mo\u001b[22m\u001b[1mx\u001b[22m\u001b[1ms\u001b[22m\u001b[1mi\u001b[22m\u001b[1mz\u001b[22m\u001b[1me\u001b[22m\u001b[1ms\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "estimate_boxsizes(dataset::AbstractDataset; k::Int = 12, z = -1, w = 1)\n",
       "```\n",
       "\n",
       "Return a `k`-element `logspace` from `lower + w` to `upper + z`,\n",
       "\n",
       "`lower` is the magnitude of the minimum pair-wise distance between datapoints while `upper` is the magnitude of the maximum difference between greatest and smallest number among each timeseries.\n",
       "\n",
       "\"Magnitude\" here stands for order of magnitude, i.e. `round(log10(x))`.\n"
      ],
      "text/plain": [
       "```\n",
       "estimate_boxsizes(dataset::AbstractDataset; k::Int = 12, z = -1, w = 1)\n",
       "```\n",
       "\n",
       "Return a `k`-element `logspace` from `lower + w` to `upper + z`,\n",
       "\n",
       "`lower` is the magnitude of the minimum pair-wise distance between datapoints while `upper` is the magnitude of the maximum difference between greatest and smallest number among each timeseries.\n",
       "\n",
       "\"Magnitude\" here stands for order of magnitude, i.e. `round(log10(x))`.\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?estimate_boxsizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1ml\u001b[22m\u001b[1mi\u001b[22m\u001b[1mn\u001b[22m\u001b[1me\u001b[22m\u001b[1ma\u001b[22m\u001b[1mr\u001b[22m\u001b[1m_\u001b[22m\u001b[1mr\u001b[22m\u001b[1me\u001b[22m\u001b[1mg\u001b[22m\u001b[1mi\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\u001b[1ms\u001b[22m p\u001b[1ml\u001b[22mot_l\u001b[1mi\u001b[22m\u001b[1mn\u001b[22m\u001b[1me\u001b[22m\u001b[1ma\u001b[22m\u001b[1mr\u001b[22m\u001b[1m_\u001b[22m\u001b[1mr\u001b[22m\u001b[1me\u001b[22m\u001b[1mg\u001b[22m\u001b[1mi\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\u001b[1ms\u001b[22m \u001b[1ml\u001b[22m\u001b[1mi\u001b[22m\u001b[1mn\u001b[22m\u001b[1me\u001b[22m\u001b[1ma\u001b[22m\u001b[1mr\u001b[22m\u001b[1m_\u001b[22m\u001b[1mr\u001b[22m\u001b[1me\u001b[22m\u001b[1mg\u001b[22m\u001b[1mi\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "linear_regions(x, y; dxi::Int = 1, tol = 0.2) -> (lrs, tangents)\n",
       "```\n",
       "\n",
       "Identify regions where the curve `y(x)` is linear, by scanning the `x`-axis every `dxi` indices (e.g. at `x[1] to x[5], x[5] to x[10], x[10] to x[15]` and so on if `dxi=5`).\n",
       "\n",
       "If the slope (calculated using `LsqFit`) of a region of width `dxi` is approximatelly equal to that of the previous region, within tolerance `tol`, then these two regions belong to the same linear region.\n",
       "\n",
       "Return the indices of `x` that correspond to linear regions, `lrs`, and the approximated `tangents` at each region. `lrs` is a vector of `Int`.\n",
       "\n",
       "A function `plot_linear_regions` visualizes the result of using this `linear_regions` (requires `PyPlot`).\n"
      ],
      "text/plain": [
       "```\n",
       "linear_regions(x, y; dxi::Int = 1, tol = 0.2) -> (lrs, tangents)\n",
       "```\n",
       "\n",
       "Identify regions where the curve `y(x)` is linear, by scanning the `x`-axis every `dxi` indices (e.g. at `x[1] to x[5], x[5] to x[10], x[10] to x[15]` and so on if `dxi=5`).\n",
       "\n",
       "If the slope (calculated using `LsqFit`) of a region of width `dxi` is approximatelly equal to that of the previous region, within tolerance `tol`, then these two regions belong to the same linear region.\n",
       "\n",
       "Return the indices of `x` that correspond to linear regions, `lrs`, and the approximated `tangents` at each region. `lrs` is a vector of `Int`.\n",
       "\n",
       "A function `plot_linear_regions` visualizes the result of using this `linear_regions` (requires `PyPlot`).\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?linear_regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mk\u001b[22m\u001b[1ma\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1ma\u001b[22m\u001b[1mn\u001b[22m\u001b[1my\u001b[22m\u001b[1mo\u001b[22m\u001b[1mr\u001b[22m\u001b[1mk\u001b[22m\u001b[1me\u001b[22m\u001b[1m_\u001b[22m\u001b[1md\u001b[22m\u001b[1mi\u001b[22m\u001b[1mm\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "kaplanyorke_dim(lyapunovs::AbstractVector)\n",
       "```\n",
       "\n",
       "Calculate the Kaplan-Yorke dimension, a.k.a. Lyapunov dimension [1].\n",
       "\n",
       "## Description\n",
       "\n",
       "The Kaplan-Yorke dimension is simply the point where `cumsum(lyapunovs)` becomes zero (interpolated). If the sum of the exponents never becomes negative the function will return the length of the input vector.\n",
       "\n",
       "Useful in combination with [`lyapunovs`](@ref).\n",
       "\n",
       "## References\n",
       "\n",
       "[1] :  J. Kaplan & J. Yorke, *Chaotic behavior of multidimensional difference equations*, Lecture Notes in Mathematics vol. **730**, Springer (1979)\n"
      ],
      "text/plain": [
       "```\n",
       "kaplanyorke_dim(lyapunovs::AbstractVector)\n",
       "```\n",
       "\n",
       "Calculate the Kaplan-Yorke dimension, a.k.a. Lyapunov dimension [1].\n",
       "\n",
       "## Description\n",
       "\n",
       "The Kaplan-Yorke dimension is simply the point where `cumsum(lyapunovs)` becomes zero (interpolated). If the sum of the exponents never becomes negative the function will return the length of the input vector.\n",
       "\n",
       "Useful in combination with [`lyapunovs`](@ref).\n",
       "\n",
       "## References\n",
       "\n",
       "[1] :  J. Kaplan & J. Yorke, *Chaotic behavior of multidimensional difference equations*, Lecture Notes in Mathematics vol. **730**, Springer (1979)\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?kaplanyorke_dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mp\u001b[22m\u001b[1me\u001b[22m\u001b[1mr\u001b[22m\u001b[1mm\u001b[22m\u001b[1me\u001b[22m\u001b[1mn\u001b[22m\u001b[1mt\u001b[22m\u001b[1mr\u001b[22m\u001b[1mo\u001b[22m\u001b[1mp\u001b[22m\u001b[1my\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "permentropy(x::AbstractVector, order [, interval=1]; base = e)\n",
       "```\n",
       "\n",
       "Compute the permutation entropy [1] of given `order` from the `x` timeseries.\n",
       "\n",
       "Optionally, `interval` can be specified to use `x[t0:interval:t1]` when calculating permutation of the sliding windows between `t0` and `t1 = t0 + interval * (order - 1)`.\n",
       "\n",
       "Optionally use `base` for the logarithms.\n",
       "\n",
       "## References\n",
       "\n",
       "[1] : C. Bandt, & B. Pompe, [Phys. Rev. Lett. **88** (17), pp 174102 (2002)](http://doi.org/10.1103/PhysRevLett.88.174102)\n"
      ],
      "text/plain": [
       "```\n",
       "permentropy(x::AbstractVector, order [, interval=1]; base = e)\n",
       "```\n",
       "\n",
       "Compute the permutation entropy [1] of given `order` from the `x` timeseries.\n",
       "\n",
       "Optionally, `interval` can be specified to use `x[t0:interval:t1]` when calculating permutation of the sliding windows between `t0` and `t1 = t0 + interval * (order - 1)`.\n",
       "\n",
       "Optionally use `base` for the logarithms.\n",
       "\n",
       "## References\n",
       "\n",
       "[1] : C. Bandt, & B. Pompe, [Phys. Rev. Lett. **88** (17), pp 174102 (2002)](http://doi.org/10.1103/PhysRevLett.88.174102)\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?permentropy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.6.2",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
